package core;

import com.sun.lwuit.Font;
import java.util.Vector;
import javax.microedition.rms.*;
import networkrespnse.OrderResponse;
import view.additional.CellItem;

public class OrderManager
{
	//Данные класса
	private Vector orders;
        private Vector currentOrders;                                           //id текущих заказов
        private Vector preOrders;                                               //Предварительные заказы
        private int claimedOrdersCount;                                         //Количество заявленных заказов
        private int maxOrdersCount;
	private String rmsName;
	private OrderListener listener;
        private int minSum;
        private Font preorderSignedFont;

	//методы класса
	public OrderManager(OrderListener _listener)
	{
		listener = _listener;
		rmsName = "orders";
		orders = new Vector();
                preOrders = new Vector();
                currentOrders = new Vector();
                maxOrdersCount = 3;
                claimedOrdersCount = 0;
                minSum = -1;
                preorderSignedFont = null;
                
		loadOrders();
	}

	public void saveOrders()//Сохранение всех заказов в RMS
	{
            //Удаляем все заказы,чтоб не дублировать данные
            try
            {
                 RecordStore.deleteRecordStore(rmsName);
            }catch(Exception e){}
            
            //Сохраняем заказы
            byte[] res;
            try
            {
                RecordStore recordStore = RecordStore.openRecordStore(rmsName, true);

                //Пока хватает места - записываем остальные заказы
                float percent = (recordStore.getSize() * 100) / recordStore.getSizeAvailable();
                
                for(int i = orders.size() - 1; i >= 0; --i)
                {
                    if ((((Order)orders.elementAt(i)).getStatus() == Order.STATE_PERFORMED) || (((Order)orders.elementAt(i)).getStatus() == Order.STATE_MISSED) ||
                             (((Order)orders.elementAt(i)).getStatus() == Order.STATE_CANCELLED))
                    {
                        res = ((Order)orders.elementAt(i)).toByte();
                        
                        if (percent < 70)
                        {
                            recordStore.addRecord(res,0,res.length);
                            //Пересчитываем процент
                            percent = (recordStore.getSize() * 100) / recordStore.getSizeAvailable();
                        }
                    }
                }
                
                recordStore.closeRecordStore();
            }catch(RecordStoreException rse){}
	}
	
	private void loadOrders()//Загрузка всех заказов из RMS
	{
		orders.removeAllElements();
		byte[] temp;

		try
		{
                    RecordStore recordStore = RecordStore.openRecordStore(rmsName, true);
                    RecordEnumeration re = recordStore.enumerateRecords(null, null, false);
                    if (re.numRecords()!=0)
                    {
                        re.rebuild();
                        while (re.hasNextElement())
                        {
                            int id = re.nextRecordId();
                            try
                            {
                                temp = recordStore.getRecord(id);
                                switch (BuildInfo.DISP_ORDER_NUMBER) {
                                    case 1 : orders.addElement(new Order(temp)); break;
                                    case 2 : orders.addElement(new Order2(temp)); break;
                                    case 3 : orders.addElement(new Order3(temp)); break;
                                    case 4 : orders.addElement(new Order4(temp)); break;
                                }
                                
                            }catch(Exception e){}
                        }
                    }
                    recordStore.closeRecordStore();
                    re.destroy();
		}catch(RecordStoreException rse){}
	}

        public String getRMSInfo()
        {
            try
            {
                RecordStore recordStore2 = RecordStore.openRecordStore(rmsName, true);
                try
                {
                   return (Integer.toString(recordStore2.getSize()) + " / " + Integer.toString(recordStore2.getSizeAvailable()));
                }
                finally
                {
                    recordStore2.closeRecordStore();
                }
            }catch(RecordStoreException rse){}
            
            return "";
        }
        
        public void setMinSum(int value)
        {
            minSum = value;
        }

        public int getMinSum()
        {
            return minSum;
        }

        public boolean outOfSum(double orderSum)
        {
            return (orderSum < minSum);
        }

        public void clearPreOrders()
        {
            preOrders.removeAllElements();
        }

        public void addPreOrder(Order newOrder,String signed, boolean isDriverSigned)
        {
            newOrder.setSigned(signed);
            newOrder.setIsDriverSigned(isDriverSigned);
            preOrders.addElement(newOrder);
        }

        public int getPreOrdersCount()
        {
            return preOrders.size();
        }
        
        public CellItem[] getPreOrdersList()
        {
            CellItem[] result = new CellItem[preOrders.size()];
            Order order;
            for (int i = 0; i < preOrders.size(); ++i)
            {
                order = (Order)preOrders.elementAt(i);
                CellItem item = new CellItem(order.getOrderID(), order.getAddress()[0]);
                if (order.isDriverSigned() && preorderSignedFont != null) {
                    item.getStyle().setFont(preorderSignedFont);
                    item.getSelectedStyle().setFont(preorderSignedFont);
                }
                
                result[i] = item;
            }

            return result;
        }
        
	public void processIncomingOrder(OrderResponse response)//Обработка пришедшего пакета с данными о заказе
	{
		if (response.getFolder().equals("Невыполненный")||response.getFolder().equals("Корзина"))
		{
                    int orderID = response.getOrder().getOrderID();
                    
                    //save order data
                    for(int i=0;i<orders.size();i++)
                    {
                        if (((Order)orders.elementAt(i)).getOrderID() == orderID)
                        {
                            ((Order)orders.elementAt(i)).copy(response.getOrder());
                        }
                    }
                    
                    orderCancel(orderID, "Отмененный");
               
                    return;
		}

                if (response.getFolder().equals("Выполненный"))
                {
                    int orderID = response.getOrder().getOrderID();

                    //Если такого заказа нет - добавляем
                    boolean notFound = true;
                    for(int i=0;i<orders.size();i++)
                    {
                            if (((Order)orders.elementAt(i)).getOrderID()==orderID)
                            {
                                ((Order)orders.elementAt(i)).copy(response.getOrder());
                                
                                notFound = false;
                                break;
                            }
                    }
                    if (notFound)
                    {
                        //Создаем новый заказ
			Order newOrder = response.getOrder();

			//Устанавливаем соответствующие свойства
			newOrder.setStatus(Order.STATE_PERFORMED);
                        
			//Добавляем заказ в коллекцию
			orders.insertElementAt(newOrder,0);
                    }

                    //удаляем из списка
                    closeOrder(orderID);

                    //Обновляем список
                    listener.orderAction();
                    
                    return;
                }

		if (response.getOrderType().equals("FindDriver1")||response.getOrderType().equals("FindDriver2")||
                    response.getOrderType().equals("FindDriver3"))
		{
                    //Если не подходит по цене
                    if (outOfSum(response.getOrder().getFare()))
                    {
                        return;
                    }

                    //Создаем новый заказ
                    Order newOrder = response.getOrder();
                    //Устанавливаем соответствующие свойства
                    newOrder.setN(Integer.parseInt(response.getOrderType().substring(10)));
                    newOrder.setFolder(response.getFolder());

                    //Если заказ с таким Id есть - удаляем
                    deleteOrder(newOrder.getOrderID());

                    //Добавляем заказ в коллекцию
                    orders.insertElementAt(newOrder,0);
                    try
                    {
                            listener.orderAction();
                    }catch(Exception e){}

                    return;
		}

		if ((response.getOrderType().equals("SendedByDispatcherFromGetFolder"))||(response.getOrderType().equals("SendedByDispatcher")))
		{
			int orderID = response.getOrder().getOrderID();
                   
                        //Проверяем нет ли такого заказа в списке выполняемых
                        boolean notExists = true;
                        for (int i=0;i<currentOrders.size();++i)
                            if (((Integer)currentOrders.elementAt(i)).intValue()==orderID)
                            {
                                notExists = false;
                                break;
                            }

                        if (notExists && (!response.getFolder().equals("Автопоиск") && !response.getFolder().equals("НаОформлении") && 
                                          !response.getFolder().equals("Входящий"))  && !response.getFolder().equals("Принятый"))
                        {
                            currentOrders.addElement(new Integer(orderID));
                        }

			//Ищем заказ с таким ИД
			for(int i=0;i<orders.size();i++)
			{
				if (((Order)orders.elementAt(i)).getOrderID()==orderID)
				{
                                    //Изменяем соответствующие свойства
                                    ((Order)orders.elementAt(i)).copy(response.getOrder());
                                    ((Order)orders.elementAt(i)).setFolder(response.getFolder());

                                    //Обновляем информацию
                                    String folderValue = response.getFolder();
                                    if (folderValue.equals("Автопоиск") || folderValue.equals("Входящий"))
                                    {
                                        ((Order)orders.elementAt(i)).setStatus(Order.STATE_NEW);
                                    }
                                    else if (folderValue.equals("НаОформлении") || folderValue.equals("Принятый"))
                                    {
                                        if (((Order)orders.elementAt(i)).getStatus() != Order.STATE_TAKEN)
                                        {
                                            claimedOrdersCount++;
                                        }
                                        ((Order)orders.elementAt(i)).setStatus(Order.STATE_TAKEN);
                                    }
                                    else if (folderValue.equals("Направленный") || folderValue.equals("Исполняемый"))
                                    {
                                        if (((Order)orders.elementAt(i)).getStatus()== Order.STATE_TAKEN)
                                        {
                                            claimedOrdersCount--;
                                        }
                                        ((Order)orders.elementAt(i)).setStatus(Order.STATE_PERFORMING);
                                    }

                                    listener.orderAction();
                                    return;
				}
			}
			//Если заказа нет в векторе - сохраняем
			//Создаем новый заказ
			Order newOrder = response.getOrder();
                        String folderValue = response.getFolder();
                        newOrder.setFolder(folderValue);
			//Устанавливаем соответствующие свойства
                        if (folderValue.equals("Автопоиск") || folderValue.equals("Входящий"))
                        {
                            newOrder.setStatus(Order.STATE_NEW);
                        }
                        else if (folderValue.equals("НаОформлении") || folderValue.equals("Принятый"))
                        {
                            newOrder.setStatus(Order.STATE_TAKEN);
                            claimedOrdersCount++;
                        }
                        else if (folderValue.equals("Направленный") || folderValue.equals("Исполняемый"))
                        {
                            newOrder.setStatus(Order.STATE_PERFORMING);
                        }
			//Добавляем заказ в коллекцию
			orders.insertElementAt(newOrder,0);
			listener.orderAction();
		}
	}

        public int getMyOrdersCount()
        {
            int count = 0;
            for(int i=0;i<orders.size();i++)
            {
                if ((((Order)orders.elementAt(i)).getStatus()== Order.STATE_PERFORMING)||(((Order)orders.elementAt(i)).getStatus()== Order.STATE_TAKEN))
                {
                        count++;
                }
            }

            return count;
        }

        public int getIncomingOrdersCount()
        {
            int count = 0;
            for(int i=0;i<orders.size();i++)
            {
                if ((((Order)orders.elementAt(i)).getStatus()==Order.STATE_NEW)&&(((Order)orders.elementAt(i)).getN()!=3))
                {
                        count++;
                }
            }

            return count;
        }

	public int getNewOrderCount()
	{
            int count;
            count = 0;
            for(int i=0;i<orders.size();i++)
            {
                if ((((Order)orders.elementAt(i)).getStatus() == Order.STATE_NEW)&&(((Order)orders.elementAt(i)).getN()==3))
                {
                        count++;
                }
            }
            return count;
	}
	
	public int getOldOrderCount()
	{
		int count;
		count = 0;
		for(int i=0;i<orders.size();i++)
		{
			if ((((Order)orders.elementAt(i)).getStatus()== Order.STATE_PERFORMING)||(((Order)orders.elementAt(i)).getStatus()== Order.STATE_TAKEN))
			{
				count++;
			}
			if ((((Order)orders.elementAt(i)).getStatus()==Order.STATE_NEW)&&(((Order)orders.elementAt(i)).getN()!=3))
			{
				count++;
			}
		}
		return count;
	}
	
	public int[] getCompletedOrderCount()
	{
		int[] res;
                res = new int[3];
                res[0] = 0; res[1] = 0; res[2] = 0;
		int status;
                for(int i=0;i<orders.size();i++)
		{
                    status = ((Order)orders.elementAt(i)).getStatus();
                    if (status== Order.STATE_PERFORMED)
                    {
                        res[0]++;
                    }
                    else if (status == Order.STATE_CANCELLED)
                    {
                        res[1]++;
                    }
                    else if (status== Order.STATE_MISSED)
                    {
                        res[2]++;
                    }
		}
		return res;
        }

        public CellItem[] getMyOrdersLis()
        {
            int count = getMyOrdersCount();
            CellItem tempItem;
            CellItem[] res = new CellItem[count];

            //Инициализируем начальный элемент на всякий случай
            if (res.length > 0)
            {
                res[0] = null;
            }

            int index = 1;
            //Если нет текущих заказов
            if (currentOrders.isEmpty())
            {
                index = 0;
            }

            //Перебираем все заказы и ищем не новые
            Order tmpOrder;
            for(int i=0;i<orders.size();i++)
            {
                tmpOrder = (Order)orders.elementAt(i);

                if (((tmpOrder.getStatus()== Order.STATE_PERFORMING)||(tmpOrder.getStatus()== Order.STATE_TAKEN)))
                {      
                    tempItem = new CellItem(tmpOrder.getOrderID(), tmpOrder.getShortDescription());
                    try
                    {
                        if (tmpOrder.getOrderID() == currentOrder())
                        {
                            res[0] = tempItem;
                        }
                        else
                        {
                            res[index++] = tempItem;
                        }
                    }catch(Exception e){}
                }
            }
            return res;
        }

        public CellItem[] getIncomingOrdersLis()
	{
            int count = getIncomingOrdersCount();
            CellItem[] res = new CellItem[count];
            int index = 0;

            //Перебираем все заказы и ищем новые
            for(int i=0;i<orders.size();i++)
            {
                if ((((Order)orders.elementAt(i)).getStatus() == Order.STATE_NEW)&&(((Order)orders.elementAt(i)).getN()!=3))
                {
                    try
                    {
                        res[index++] = new CellItem(((Order)orders.elementAt(i)).getOrderID(), ((Order)orders.elementAt(i)).getShortDescription());
                    }catch(Exception e){}
                }
            }
            return res;
	}

	public CellItem[] getOrdersLis()
	{
            int count = getNewOrderCount();
            CellItem[] res = new CellItem[count];
            int index = 0;

            String tempStr;
            //Перебираем все заказы и ищем новые
            for(int i=0;i<orders.size();i++)
            {
                if ((((Order)orders.elementAt(i)).getStatus() == Order.STATE_NEW)&&(((Order)orders.elementAt(i)).getN()==3))
                {
                    try
                    {
                        res[index++] = new CellItem(((Order)orders.elementAt(i)).getOrderID(), ((Order)orders.elementAt(i)).getShortDescription());
                    }catch(Exception e){}
                }
            }
            return res;
	}	
		
	public CellItem[] getCompletedOrderLis(int orderType)
	{
            int[] count = getCompletedOrderCount();
            CellItem[] res = null;
            switch (orderType)
            {
                case Order.STATE_PERFORMED: res = new CellItem[count[0]];break;
                case Order.STATE_CANCELLED: res = new CellItem[count[1]];break;
                case Order.STATE_MISSED: res = new CellItem[count[2]];break;
            }
            int index = 0;

            //Перебираем все заказы и ищем необходимый
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).getStatus()==orderType)
                {
                    try
                    {
                        res[index++] = new CellItem(((Order)orders.elementAt(i)).getOrderID(), ((Order)orders.elementAt(i)).getShortDescription());
                    }catch(Exception e){}
                }
            }
            return res;
	}
	
	public CellItem[] getOldOrdersLis()
	{
            int count = getOldOrderCount();
            CellItem tempItem;
            CellItem[] res = new CellItem[count];

            //Инициализируем начальный элемент на всякий случай
            if (res.length > 0)
            {
                res[0] = null;
            }

            int index = 1;
            //Если нет текущих заказов
            if (currentOrders.isEmpty())
            {
                index = 0;
            }

            //Перебираем все заказы и ищем не новые
            Order tmpOrder;
            for(int i=0;i<orders.size();i++)
            {
                tmpOrder = (Order)orders.elementAt(i);

                if (((tmpOrder.getStatus()== Order.STATE_PERFORMING)||(tmpOrder.getStatus()== Order.STATE_TAKEN))||
                   ((tmpOrder.getStatus()== Order.STATE_NEW)&&(tmpOrder.getN()!=3)))
                {
                    tempItem = new CellItem(tmpOrder.getOrderID(), tmpOrder.getShortDescription());
                    try
                    {
                        if (tmpOrder.getOrderID() == currentOrder())
                        {
                            res[0] = tempItem;
                        }
                        else
                        {
                            res[index++] = tempItem;
                        }
                    }catch(Exception e){}
                }
            }
            return res;
	}

        public Order getPreOrder(int id)
        {
            for (int i = 0; i < preOrders.size(); ++i)
            {
                if (((Order)preOrders.elementAt(i)).getOrderID() == id)
                {
                    return (Order)preOrders.elementAt(i);
                }
            }
            return null;
        }

	public OrderDatails getOrderDetails(int ID, boolean fullData, String type)
	{
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).getOrderID()==ID)
                {
                    OrderDatails result = new OrderDatails(((Order)orders.elementAt(i)).getDetailsText(fullData, type));
                    result.setIsNew(((Order)orders.elementAt(i)).getStatus() == Order.STATE_NEW);
                    return result;
                }
            }
            
            return new OrderDatails("Данные по заказу не были найдены", true);
	}
	
        public void deleteAllEfirOrders()
        {
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).isNewEfirOrder())
                {
                    //MainOne.LOG_STR += "(" + ID + ") " + ((Order)orders.elementAt(i)).getAddress()[0] + " reson=1;\n";
                    orders.removeElementAt(i);
                    break;
                }
            }
        }
        
        public void deleteEfirOrder(int ID)
        {
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).getOrderID()==ID && ((Order)orders.elementAt(i)).isNewEfirOrder())
                {
                    //MainOne.LOG_STR += "(" + ID + ") " + ((Order)orders.elementAt(i)).getAddress()[0] + " reson=1;\n";
                    orders.removeElementAt(i);
                    break;
                }
            }
        }
        
	public void deleteOrder(int ID)
	{
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).getOrderID()==ID)
                {
                    //MainOne.LOG_STR += "(" + ID + ") " + ((Order)orders.elementAt(i)).getAddress()[0] + " reson=1;\n";
                    orders.removeElementAt(i);
                    break;
                }
            }
	}
	
        public void setFolder(int ID,String folder)
	{
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).getOrderID()==ID)
                {                          
                    ((Order)orders.elementAt(i)).setFolder(folder);
                    break;
                }
            }
	}
        
	public void setState(int ID,int value)
	{
		for(int i=0;i<orders.size();i++)
		{
			if (((Order)orders.elementAt(i)).getOrderID()==ID)
			{
                            //Если водитель заявляет что берет этот заказ - увеличиваем счетчик
                            if (value==4)
                            {
                                claimedOrdersCount++;
                            }
                            else if (((Order)orders.elementAt(i)).getStatus()== Order.STATE_TAKEN)
                            {
                                claimedOrdersCount--;
                            }
                            
                            ((Order)orders.elementAt(i)).setStatus(value);
                            break;
			}
		}
	}
	
	public int getOrderState(int ID)
	{
		for(int i=0;i<orders.size();i++)
		{
			if (((Order)orders.elementAt(i)).getOrderID()==ID)
			{
				return ((Order)orders.elementAt(i)).getStatus();
			}
		}
		return -1;
	}

        public String getDispetcherPhoneNumber(int id)
        {
            for(int i=0;i<orders.size();i++)
            {
                    if (((Order)orders.elementAt(i)).getOrderID() == id && orders.elementAt(i) instanceof Order2)
                    {
                        return ((Order2)orders.elementAt(i)).getDispPhone();
                    }
            }
            return "";
        }
        
        public String getClietntsPhoneNumber(int id)
        {
            for(int i=0;i<orders.size();i++)
            {
                    if (((Order)orders.elementAt(i)).getOrderID() == id)
                    {
                            return ((Order)orders.elementAt(i)).getPhoneNumber();
                    }
            }
            return "";
        }

	public int getN(int ID)
	{
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).getOrderID()==ID)
                {
                        return ((Order)orders.elementAt(i)).getN();
                }
            }
            return -1;
	}
	
	public String getPhone(int ID)
	{
		for(int i=0;i<orders.size();i++)
		{
			if (((Order)orders.elementAt(i)).getOrderID()==ID)
			{
				return ((Order)orders.elementAt(i)).getPhoneNumber();
			}
		}
		return "";
	}
	
	public String[] getReport(long from,long to)
	{
            int totalSum;
            Vector temp;
            String[] res;
            temp = new Vector();
            totalSum = 0;
            for(int i=0;i<orders.size();i++)
            {
                if (((((Order)orders.elementAt(i)).getStatus()== Order.STATE_PERFORMED)||(((Order)orders.elementAt(i)).getStatus()==7))
                        &&(((Order)orders.elementAt(i)).getDate()>from)&&(((Order)orders.elementAt(i)).getDate()<to))
                {
                    temp.addElement(((Order)orders.elementAt(i)).getReportDescription());
                    totalSum += ((Order)orders.elementAt(i)).getFare();
                }
            }
            res = new String[temp.size()+1];
            for (int i=0;i<temp.size();i++)
            {
                res[i] = ((String)temp.elementAt(i));
            }
            res[res.length-1] = Integer.toString(totalSum);
            return res;
	}
	
	public boolean isDeleted(int ID,int T1,int T2,int T3)
	{
		//Формируем массив со временем
		int[] T;
		T = new int[3];
		T[0] = T1;
		T[1] = T2;
		T[2] = T3;
		//Проверяем состояние заказа
		for(int i=orders.size()-1;i>=0;i--)
		{
			if (((Order)orders.elementAt(i)).getOrderID()==ID)
			{
				return ((Order)orders.elementAt(i)).isDeleted(T);
			}
		}
		
		return false;
	}
	
	public void autoClear(int T1,int T2,int T3)
	{
		int[] T;
		T = new int[3];
		T[0] = T1;
		T[1] = T2;
		T[2] = T3;
                int canceledCount = 0;
                int missedCount = 0;
                int performedCount = 0;
                Order order;
		for(int i=orders.size()-1;i>=0;i--)
		{
                    order = (Order)orders.elementAt(i); 
                    if (order.isTooOld(T))
                    {
                        //MainOne.LOG_STR += "(" + ((Order)orders.elementAt(i)).getOrderID() + ") " + ((Order)orders.elementAt(i)).getAddress()[0] + " reson=2;\n";
                        orders.removeElementAt(i);
                    } else if (order.getStatus() == Order.STATE_CANCELLED) {
                        canceledCount++;
                    } else if (order.getStatus() == Order.STATE_MISSED) {
                        missedCount++;
                    } else if (order.getStatus() == Order.STATE_PERFORMED) {
                        performedCount++;
                    }
		}

                int maxArchivOrdersCount = Settings.getSettings().getMaxArchivOrdersCount();
                for(int i = orders.size() - 1; (i >= 0) && (canceledCount > maxArchivOrdersCount ||
                                                            missedCount > maxArchivOrdersCount || 
                                                            performedCount > missedCount); --i) {
                    order = (Order)orders.elementAt(i); 
                    if (order.getStatus() == Order.STATE_CANCELLED && canceledCount > maxArchivOrdersCount) {
                        orders.removeElementAt(i);
                        canceledCount--;
                    } else if (order.getStatus() == Order.STATE_MISSED && missedCount > maxArchivOrdersCount) {
                        orders.removeElementAt(i);
                        missedCount--;
                    } else if (order.getStatus() == Order.STATE_PERFORMED && performedCount > maxArchivOrdersCount) {
                        orders.removeElementAt(i);
                        performedCount--;
                    }
                }
                order = null;    
	}
	
        public void clearAllExceptArchive() {
            //Чистим текущие заказы
            currentOrders.removeAllElements();
            
            //Чистим коллекцию заказов
            int status;
            for(int i = orders.size() - 1; i >= 0; --i) {
                status = ((Order)orders.elementAt(i)).getStatus();
                //Архивные заказы не трогаем
                if (status == Order.STATE_PERFORMED || status == Order.STATE_MISSED ||
                    status == Order.STATE_CANCELLED) {
                    continue;
                }
                
                //Остальные удаляем
                orders.removeElementAt(i);
            }
        }
        
	public void clear()
	{
		int status;
		
		//Удаляем ненужные заказы и сильно старые из архива
		for(int i=orders.size()-1;i>=0;i--)
		{
			status = ((Order)orders.elementAt(i)).getStatus();
			if ((status== Order.STATE_NEW)||(status== Order.STATE_TAKEN))
			{
                                //MainOne.LOG_STR += "(" + ((Order)orders.elementAt(i)).getOrderID() + ") " + ((Order)orders.elementAt(i)).getAddress()[0] + " reson=3;\n";

				orders.removeElementAt(i);
			}
		}
	}
	
	public void clearCompleted(int orderType)
	{
            //Удаление выполненных заказов
            for(int i=orders.size()-1;i>=0;i--)
            {
                if (((Order)orders.elementAt(i)).getStatus()==orderType)
                {
                    //MainOne.LOG_STR += "(" + ((Order)orders.elementAt(i)).getOrderID() + ") " + ((Order)orders.elementAt(i)).getAddress()[0] + " reson=4;\n";

                    orders.removeElementAt(i);
                }
            }
	}

        public void setMaxOrdersCount(int newCount)
        {
            maxOrdersCount = newCount;
        }

        public boolean canGetOrders()
        {
            if ((currentOrders.size()+claimedOrdersCount)>=maxOrdersCount)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        //Возвращает ID текущего заказа
        public int currentOrder()
        {
            if (currentOrders.size()>0)
            {
                return ((Integer)currentOrders.elementAt(0)).intValue();
            }
            else
            {
                return -1;
            }
        }

        public void closeOrder(int orderID)
        {
            //Изменяем статус заказа
            setState(orderID, Order.STATE_PERFORMED);
            setFolder(orderID, "Выполненный");
            //Удаляем его из очереди заказов
            for (int i=0;i<currentOrders.size();++i)
                if (((Integer)currentOrders.elementAt(i)).intValue()==orderID)
                {
                    currentOrders.removeElementAt(i);
                    break;
                }
        }

        public void closeCurrent()
        {
            //Изменяем статус заказа
            setState(currentOrder(), Order.STATE_PERFORMED);
            //Удаляем его из очереди заказов
            if (currentOrders.size()>0)
            {
                currentOrders.removeElementAt(0);
            }
        }

        public void orderCancel(int ID, String folderValue)
        {
            //Удаляем заказ из очереди на выполнение
            for (int i=0;i<currentOrders.size();++i)
                if (((Integer)currentOrders.elementAt(i)).intValue()==ID)
                {
                    currentOrders.removeElementAt(i);
                    break;
                }

            //Ищем заказ с таким ИД и помечаем eго как отмененный
            for(int i=0;i<orders.size();i++)
            {
                if (((Order)orders.elementAt(i)).getOrderID()==ID)
                {
                    ((Order)orders.elementAt(i)).setFolder(folderValue);
                    
                    if (((Order)orders.elementAt(i)).getStatus()== Order.STATE_TAKEN)
                    {
                        claimedOrdersCount--;
                    }

                    if (((Order)orders.elementAt(i)).isNewEfirOrder())
                    {
                        orders.removeElementAt(i);
                    }
                    else
                    {
                        ((Order)orders.elementAt(i)).setStatus(Order.STATE_CANCELLED);
                    }
                    
                    listener.orderAction();
                    break;
                }
            }
        }

        public void deleteTakenOrders()
        {

            for(int i = 0; i < orders.size(); i++)
            {
                if (((Order)orders.elementAt(i)).getStatus()== Order.STATE_TAKEN)
                {
                    int id = ((Order)orders.elementAt(i)).getOrderID();

                    //Удаляем заказ из очереди на выполнение
                    for (int j = 0;j < currentOrders.size(); ++j)
                    {
                        if (((Integer)currentOrders.elementAt(j)).intValue() == id)
                        {
                            currentOrders.removeElementAt(j);
                            break;
                        }
                    }

                    ((Order)orders.elementAt(i)).setStatus(Order.STATE_CANCELLED);
                    claimedOrdersCount--;
                }
            }

            //Обновляем интрефейс
            listener.orderAction();
        }

        public void deleteAll()
        {
            //Удаляем все
            currentOrders.removeAllElements();
            orders.removeAllElements();

            //Обновляем список
            listener.orderAction();
        }
        
        public class OrderDatails
        {
            private String text;
            private boolean error;
            private boolean isNew;
            
            public OrderDatails(String text)
            {
                this.text = text;
                this.error = false;
                this.isNew = false;
            }
            
            public OrderDatails(String text, boolean error)
            {
                this.text = text;
                this.error = error;
                this.isNew = false;
            }

            public String getText() 
            {
                return text;
            }

            public boolean isError() 
            {
                return error;
            }

            public boolean getIsNew() 
            {
                return isNew;
            }

            public void setIsNew(boolean isNew) 
            {
                this.isNew = isNew;
            }
            
            
        }

    public void setPreorderSignedFont(Font preorderSignedFont) {
        this.preorderSignedFont = preorderSignedFont;
    }
}
